//package com.pkx.guide.task;
//
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.pkx.guide.common.util.StringUtils;
//import com.pkx.guide.holidays.entity.THolidaysDate;
//import com.pkx.guide.holidays.key.THolidaysDateKey;
//import com.pkx.guide.info.entity.TInfoGuidePublish;
//import com.pkx.guide.info.entity.TInfoNetworkConfig;
//import com.pkx.guide.info.service.TInfoGuidePublishService;
//import com.pkx.guide.info.service.TInfoGuideService;
//import com.pkx.guide.info.service.TInfoGuideStatusService;
//import com.pkx.guide.info.service.TInfoNetworkConfigService;
//import com.pkx.guide.qianfeng.service.QianFengPlayLedService;
//import jakarta.annotation.Resource;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//
//import java.time.DayOfWeek;
//import java.time.LocalDate;
//import java.time.LocalDateTime;
//import java.time.format.DateTimeFormatter;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//
///**
// * 三四 自动发布任务
// *
// * @Author : YangLe
// * @create 2025/9/22 09:45
// */
//@Slf4j
//@Component
//public class SanSiAutomatic {
//    @Resource
//    private TInfoGuideStatusService tInfoGuideStatusService;
//    // 依赖注入（假设已通过Spring注入）
//    @Autowired
//    private TInfoGuidePublishService tInfoGuidePublishService;
//    @Resource
//    private TInfoNetworkConfigService infoNetworkConfigService;
//    @Autowired
//    private TInfoGuideService tInfoGuideService;
//
//    @Autowired
//    private RedisTemplate redisTemplate;
//
//    @Resource
//    private QianFengPlayLedService qianFengPlayLedService;
//    /**
//     * 每10秒执行一次：仅在节假日、调休日、周六周日检查设备状态，离线则发布
//     */
//    // 1. 类级别定义统一的格式器（关键：避免局部重定义导致混乱）
//    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
//    private static final DateTimeFormatter DATE_TIME_FORMATTER_FULL = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//    private static final DateTimeFormatter DATE_TIME_FORMATTER_DATE_ONLY = DateTimeFormatter.ISO_LOCAL_DATE;
//
//    @Scheduled(
//            cron = "0 00,15,30,45 * * * ?"
//    )
//    public void autoPublishByDate() {
//        try {
//
//            log.info("开始三四自动发布检查（节假日/调休/周末专用）");
//            LocalDate today = LocalDate.now();
//            //当前时间 时分秒
//            String todayDateStr = today.format(DATE_FORMATTER);
//            LocalDateTime currentTime = LocalDateTime.now();
//
//
//            ArrayList<String> strings = new ArrayList<>();
//            //判断今天周六日
//
//
//            List<THolidaysDate> holidaysList = getHolidaysListFromRedis();
//
//            if (!holidaysList.isEmpty() || holidaysList != null || holidaysList.size() > 0) {
//                for (THolidaysDate tHolidaysDate : holidaysList) {
//
//
//                    String startTime = tHolidaysDate.getStartTime();
//                    String endTime = tHolidaysDate.getEndTime();
//                    //我要判断 今天是不是  startTime = 和endTime =之间
//                    if (todayDateStr.compareTo(startTime) >= 0 && todayDateStr.compareTo(endTime) <= 0) {
//                        strings.add(todayDateStr);
//                    }
//
//                    //判断今天是不是调休
//                    String adjustedTime = tHolidaysDate.getAdjustedTime();
//                    if (adjustedTime != null &&  adjustedTime != "") {
//                        // 处理逗号分隔的多个调休日期
//                        String[] adjustedDateTimeStrs = adjustedTime.split(",");
//                        for (String dateTimeStr : adjustedDateTimeStrs) {
//                            String adjustedDate = extractDateFromDateTimeStr(dateTimeStr);
//                            // 判断当前日期是否等于调休日期
//
//                            for (String string : strings) {
//                                // 判断当前日期是否等于调休日期
//                                if (!string.equals(adjustedDate)) {
//                                    strings.add(adjustedDate);
//                                }
//                            }
//                        }
//                    }
//                }
//                for (String string : strings) {
//                    if (string.equals(todayDateStr)) {
//                        // 2. 步骤1：查询基础符合条件的任务（未删除、待处理）
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.list(new LambdaQueryWrapper<TInfoGuidePublish>()
//                                .eq(TInfoGuidePublish::getDelFlg, 0)
//                                .eq(TInfoGuidePublish::getState, 0)
//                                .eq(TInfoGuidePublish::getHolidays, 0)
//                        );
//                        log.info("符合节假日的总数", basePublishList.size());
//
//                        // 3. 步骤2：筛选“任务时间（当天+startTimeScale）晚于当前时间”的任务
//                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("合符节假日经过时间筛选后的任务数量：{}", filteredList.size());
//                        extracted(filteredList);
//
//                    }
//                }
//
//            }
//            if (today.getDayOfWeek() == DayOfWeek.SATURDAY || today.getDayOfWeek() == DayOfWeek.SUNDAY) {
//                strings.add(todayDateStr);
//            }
//
//            if (strings.isEmpty()) {
//                List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.list(new LambdaQueryWrapper<TInfoGuidePublish>()
//                        .eq(TInfoGuidePublish::getDelFlg, 0)
//                        .eq(TInfoGuidePublish::getState, 0)
//                        .eq(TInfoGuidePublish::getHolidays, 1)
//                );
//
//                // 3. 步骤2：筛选“任务时间（当天+startTimeScale）晚于当前时间”的任务
//                List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//
//                extracted(filteredList);
//
//            }else {
//                for (String string : strings) {
//                    if (string.equals(todayDateStr)) {
//                        // 2. 步骤1：查询基础符合条件的任务（未删除、待处理）
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.list(new LambdaQueryWrapper<TInfoGuidePublish>()
//                                .eq(TInfoGuidePublish::getDelFlg, 0)
//                                .eq(TInfoGuidePublish::getState, 0)
//                                .eq(TInfoGuidePublish::getHolidays, 0)
//                        );
//                        log.info("符合周六日的总数", basePublishList.size());
//
//                        // 3. 步骤2：筛选“任务时间（当天+startTimeScale）晚于当前时间”的任务
//                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("合符周六日经过时间筛选后的任务数量：{}", filteredList.size());
//                        extracted(filteredList);
//
//                    }
//                }
//
//            }
//
//
//        } catch (Exception e) {
//            log.error("自动发布执行异常", e);
//        }
//    }
//
//    private void extracted(List<TInfoGuidePublish> filteredList) throws Exception {
//        log.info("开始处理任务");
//        ObjectMapper objectMapper = new ObjectMapper();
//
//        for (TInfoGuidePublish task : filteredList) {
//            // 5.2 解析发布详情（IP列表）
//            String publishDetail = task.getPublishDetail();
//            if (StringUtils.isEmpty(publishDetail)) {
//                log.warn("任务[{}]：发布详情为空，跳过处理", task.getId());
//                continue;
//            }
//
//            // 5.3 检查设备状态并发布
//            checkDeviceAndPublish(task);
//            log.info("任务[{}]：发布成功", task.getId());
//
//        }
//    }
//
//
//    /**
//     * 子方法：筛选“任务时间晚于当前时间”的任务
//     */
//    private List<TInfoGuidePublish> filterTasksByTime(List<TInfoGuidePublish> baseList, String todayDateStr, LocalDateTime currentTime) {
//        List<TInfoGuidePublish> result = new ArrayList<>();
//        for (TInfoGuidePublish task : baseList) {
//            String startTimeScale = task.getStartTimeScale();
//            String endTimeScale = task.getEndTimeScale();
//            if (StringUtils.isEmpty(startTimeScale)) {
//                log.warn("任务[{}]：startTimeScale为空，跳过筛选", task.getId());
//                continue;
//            }
//            if (StringUtils.isEmpty(endTimeScale)) {
//                log.warn("任务[{}]：endTimeScale为空，跳过筛选", task.getId());
//                continue;
//            }
//
//            try {
//                // 补全时间为 yyyy-MM-dd HH:mm:ss 格式
//                String completeTime = 补全时间(startTimeScale);
//                String completeEndTime = 补全时间(endTimeScale);
//                String fullTimeStr = todayDateStr + " " + completeTime;
//                String fullTimeEnd = todayDateStr + " " + completeEndTime;
//                // 用完整格式器解析（此时fullTimeStr已确保是 HH:mm:ss 格式）
//                LocalDateTime taskTime = LocalDateTime.parse(fullTimeStr, DATE_TIME_FORMATTER_FULL);
//                LocalDateTime endTime = LocalDateTime.parse(fullTimeEnd, DATE_TIME_FORMATTER_FULL);
//
//                // 核心筛选：开始时间<=当前时间<结束时间
//                if (!taskTime.isAfter(currentTime) && currentTime.isBefore(endTime)) {
//                    result.add(task);
//                    log.debug("任务[{}]：符合时间条件（开始时间：{} <= 当前时间：{} < 结束时间：{}）",
//                            task.getId(),
//                            taskTime.format(DATE_TIME_FORMATTER_FULL),
//                            currentTime.format(DATE_TIME_FORMATTER_FULL),
//                            endTime.format(DATE_TIME_FORMATTER_FULL));
//                }
//            } catch (Exception e) {
//                // 这里可以添加异常处理逻辑
//                log.error("处理任务[{}]时间时发生错误", task.getId(), e);
//            }
//        }
//        return result;
//    }
//
//    /**
//     * 子方法：补全时间为 HH:mm:ss 格式（兼容 HH、HH:mm、HH:mm:ss，新增非法片段校验）
//     *
//     * @param startTimeScale 原始时间字符串（如 "12"、"12:30"、"12:30:45"）
//     * @return 标准 HH:mm:ss 格式时间
//     * @throws IllegalArgumentException 非法时间格式时抛出
//     */
//    private String 补全时间(String startTimeScale) {
//        // 1. 分割时间片段，同时过滤空字符串（处理 "12::07" 这类多冒号的情况）
//        String[] timeParts = Arrays.stream(startTimeScale.split(":"))
//                .filter(StringUtils::isNotEmpty)
//                .toArray(String[]::new);
//
//        // 2. 校验分割后的片段数量（只能是 1、2、3 个）
//        if (timeParts.length < 1 || timeParts.length > 3) {
//            throw new IllegalArgumentException("时间片段数量非法（需1-3个）：" + startTimeScale);
//        }
//
//        // 3. 校验每个片段是否为合法数字，且符合时间范围（HH:0-23, mm/ss:0-59）
//        int hour = parseAndValidateTimePart(timeParts[0], 0, 23, "小时", startTimeScale);
//        int minute = 0;
//        int second = 0;
//
//        // 处理分钟（片段数量>=2时）
//        if (timeParts.length >= 2) {
//            minute = parseAndValidateTimePart(timeParts[1], 0, 59, "分钟", startTimeScale);
//        }
//
//        // 处理秒（片段数量=3时）
//        if (timeParts.length == 3) {
//            second = parseAndValidateTimePart(timeParts[2], 0, 59, "秒", startTimeScale);
//        }
//
//        // 4. 格式化为标准 HH:mm:ss（补前导零，确保2位）
//        return String.format("%02d:%02d:%02d", hour, minute, second);
//    }
//
//    /**
//     * 辅助方法：解析时间片段并校验范围（避免重复代码）
//     *
//     * @param part     时间片段（如 "12"、"30"）
//     * @param min      最小值（如小时0，分钟0）
//     * @param max      最大值（如小时23，分钟59）
//     * @param partName 片段名称（用于错误提示，如 "小时"、"分钟"）
//     * @param original 原始时间字符串（用于错误提示）
//     * @return 解析后的整数
//     * @throws IllegalArgumentException 非法数字或超出范围时抛出
//     */
//    private int parseAndValidateTimePart(String part, int min, int max, String partName, String original) {
//        int value;
//        try {
//            // 解析为整数（处理 "08" 这类带前导零的情况，Integer.parseInt 会自动转为8，不影响）
//            value = Integer.parseInt(part);
//        } catch (NumberFormatException e) {
//            throw new IllegalArgumentException(
//                    String.format("时间%s包含非法数字（%s）：%s", partName, part, original), e);
//        }
//
//        // 校验范围
//        if (value < min || value > max) {
//            throw new IllegalArgumentException(
//                    String.format("时间%s超出范围（需%d-%d）：%s", partName, min, max, original));
//        }
//        return value;
//    }
//
//    /**
//     * 子方法：检查设备状态并执行发布
//     */
//    private void checkDeviceAndPublish(TInfoGuidePublish task) throws Exception {
//        log.info("开始发布");
//
//        // 查询乾丰上位机网络配置
//        TInfoNetworkConfig networkConfig = infoNetworkConfigService.selectByGuideType(1);
//        if (networkConfig == null) {
//            throw new RuntimeException("未查询到网络配置信息");
//        }
//        JSONObject param = new JSONObject();
//        param.put("user", networkConfig.getUsername());
//        param.put("pwd", networkConfig.getPassword());
//        param.put("cmd", "1");
//        param.put("data", JSONArray.parseArray(task.getPublishDetail()));
//
//        String result = qianFengPlayLedService.controlLed(networkConfig.getIp(), networkConfig.getPort(), param.toJSONString());
//        log.info("手动发布结果：{}", result);
//        JSONObject resultJson = JSONObject.parseObject(result);
//        if (resultJson == null) {
//            log.warn("任务[{}]：IP[{}]设备状态异常（{}），不执行发布", task.getId());
//        } else {
//            String code = resultJson.getString("code");
//            if (!"0".equals(code)) {
//                log.warn("任务[{}]：IP[{}]设备状态异常（{}），不执行发布", task.getId());
//            }
//            // 保存情报板发布状态
//            tInfoGuideStatusService.updateGuideStatus(task.getPublishDetail());
//        }
//        log.info("任务[{}]：IP[{}]发布结果：{}",
//                task.getId(), JSONObject.toJSONString(result));
//
//    }
//
//
//
//
//
//    /**
//     * 修复：根据字符串长度选择格式器（避免解析短格式报错）
//     * - 长度10：仅年月日（yyyy-MM-dd）→ 用 DATE_TIME_FORMATTER_DATE_ONLY
//     * - 长度19：完整时分秒（yyyy-MM-dd HH:mm:ss）→ 用 DATE_TIME_FORMATTER_FULL
//     */
//    private String extractDateFromDateTimeStr(String dateTimeStr) {
//        if (StringUtils.isEmpty(dateTimeStr)) {
//            log.warn("时间字符串为空，跳过解析");
//            return "";
//        }
//        try {
//            LocalDate date;
//            if (dateTimeStr.length() == 10) {
//                // 仅年月日（如 "2025-08-29"）
//                date = LocalDate.parse(dateTimeStr, DATE_TIME_FORMATTER_DATE_ONLY);
//            } else if (dateTimeStr.length() == 19) {
//                // 完整时分秒（如 "2025-08-29 00:00:00"）
//                LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, DATE_TIME_FORMATTER_FULL);
//                date = dateTime.toLocalDate();
//            } else {
//                log.warn("时间字符串长度异常（既非10也非19）：{}", dateTimeStr);
//                return "";
//            }
//            return date.format(DATE_FORMATTER);
//        } catch (Exception e) {
//            // 兜底：直接截取前10位（避免解析失败导致整个流程中断）
//            log.warn("时间字符串解析失败，尝试截取前10位：{}，错误：{}", dateTimeStr, e.getMessage());
//            return dateTimeStr.length() >= 10 ? dateTimeStr.substring(0, 10) : "";
//        }
//    }
//
//    /**
//     * 从Redis获取节假日列表（保持不变）
//     */
//    public List<THolidaysDate> getHolidaysListFromRedis() {
//        try {
//            Object result = redisTemplate.opsForValue().get(THolidaysDateKey.KEY_HOLIDAYS_ALL);
//            if (result instanceof List<?>) {
//                List<?> list = (List<?>) result;
//                if (list.isEmpty() || list.get(0) instanceof THolidaysDate) {
//                    return (List<THolidaysDate>) list;
//                }
//                log.warn("Redis中节假日数据元素类型不符，预期THolidaysDate");
//            } else {
//                log.warn("Redis中未找到有效节假日数据（非List类型）");
//            }
//        } catch (Exception e) {
//            log.error("从Redis获取节假日数据失败", e);
//        }
//        return List.of();
//    }
//}
//
